track_matrix.h

Go to the documentation of this file.

// WOLF - Copyright (C) 2020-2026
// Institut de Robòtica i Informàtica Industrial, CSIC-UPC.
// Authors: Joan Solà Ortega (jsola@iri.upc.edu) and
// Joan Vallvé Navarro (jvallve@iri.upc.edu)
// All rights reserved.
//
// This file is part of WOLF: http://www.iri.upc.edu/wolf
// WOLF is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
 
#include "core/feature/feature_base.h"
#include "core/capture/capture_base.h"
 
#include <map>
#include <vector>
#include <list>
#include <utility>
 
namespace wolf
{
using std::list;
using std::map;
using std::pair;
using std::shared_ptr;
using std::vector;
 
typedef map<TimeStamp, FeatureBasePtr>                      Track;
typedef map<TimeStamp, FeatureBaseConstPtr>                 TrackConst;
typedef map<SizeStd, FeatureBasePtr>                        Snapshot;
typedef map<SizeStd, FeatureBaseConstPtr>                   SnapshotConst;
typedef map<SizeStd, pair<FeatureBasePtr, FeatureBasePtr> > TrackMatches;  // matched feature pairs indexed by track_id
typedef map<SizeStd, pair<FeatureBaseConstPtr, FeatureBaseConstPtr> >
    TrackMatchesConst;  // matched feature pairs indexed by track_id
 
class TrackMatrix
{
  public:
    TrackMatrix();
    virtual ~TrackMatrix();
 
    void newTrack(FeatureBasePtr _ftr);
    void add(const SizeStd& _track_id, const FeatureBasePtr& _ftr);
    void add(const FeatureBasePtr& _ftr_existing, const FeatureBasePtr& _ftr_new);
    void remove(FeatureBasePtr _ftr);
    void remove(const SizeStd& _track_id);
    void remove(CaptureBasePtr _cap);
 
    SizeStd                     numTracks() const;
    SizeStd                     trackSize(const SizeStd& _track_id) const;
    TrackConst                  track(const SizeStd& _track_id) const;
    Track                       track(const SizeStd& _track_id);
    SnapshotConst               snapshot(CaptureBaseConstPtr _capture) const;
    Snapshot                    snapshot(CaptureBasePtr _capture);
    vector<FeatureBaseConstPtr> trackAsVector(const SizeStd& _track_id) const;
    vector<FeatureBasePtr>      trackAsVector(const SizeStd& _track_id);
    FeatureBaseConstPtrList     snapshotAsList(CaptureBaseConstPtr _cap) const;
    FeatureBasePtrList          snapshotAsList(CaptureBasePtr _cap);
    TrackMatchesConst           matches(CaptureBaseConstPtr _cap_1, CaptureBaseConstPtr _cap_2) const;
    TrackMatches                matches(CaptureBasePtr _cap_1, CaptureBasePtr _cap_2);
 
    FeatureBaseConstPtr firstFeature(const SizeStd& _track_id) const;
    FeatureBasePtr      firstFeature(const SizeStd& _track_id);
    FeatureBaseConstPtr lastFeature(const SizeStd& _track_id) const;
    FeatureBasePtr      lastFeature(const SizeStd& _track_id);
    FeatureBaseConstPtr feature(const SizeStd& _track_id, CaptureBaseConstPtr _cap) const;
    FeatureBasePtr      feature(const SizeStd& _track_id, CaptureBasePtr _cap);
    CaptureBaseConstPtr firstCapture(const SizeStd& _track_id) const;
    CaptureBasePtr      firstCapture(const SizeStd& _track_id);
    CaptureBaseConstPtr lastCapture(const SizeStd& _track_id) const;
    CaptureBasePtr      lastCapture(const SizeStd& _track_id);
 
    list<SizeStd> trackIds(CaptureBaseConstPtr _capture = nullptr) const;
 
    // tracks across captures that belong to keyframe
    TrackConst trackAtKeyframes(const SizeStd& _track_id) const;
    Track      trackAtKeyframes(const SizeStd& _track_id);
 
    // Remove snapshots of captures that are being removed from the problem (e.g. when a keyframe is removed)
    void cleanSnapshots();
 
  private:
    static SizeStd track_id_count_;
 
    // tracks across all Captures
    map<SizeStd, Track> tracks_;  // map indexed by track_Id   of ( maps indexed by TimeStamp  of ( features ) )
 
    // Across track: maps of Feature pointers indexed by track_Id.
    map<CaptureBasePtr, Snapshot>
        snapshots_;  // map indexed by capture_ptr of ( maps indexed by track_Id of ( features ) )
};
 
} /* namespace wolf */